package com.zenithmind.library.adapter;

import com.zenithmind.common.result.PageResult;
import com.zenithmind.common.result.Result;
import com.zenithmind.library.pojo.dto.AuthorCreateDTO;
import com.zenithmind.library.pojo.dto.BookCreateDTO;
import com.zenithmind.library.pojo.query.AuthorQuery;
import com.zenithmind.library.pojo.query.BookQuery;
import com.zenithmind.library.pojo.vo.AuthorVO;
import com.zenithmind.library.pojo.vo.BookVO;
import com.zenithmind.library.service.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 图书馆服务适配器
 * 为其他服务提供兼容性接口，确保重构后的接口变更不影响其他服务
 * 遵循适配器模式：将新的接口适配为旧的接口格式
 * 
 * @author ZenithMind
 * @since 2024-06-14
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class LibraryServiceAdapter {

    // 注入新的细分服务接口
    private final AuthorQueryService authorQueryService;
    private final AuthorManagementService authorManagementService;
    private final AuthorStatisticsService authorStatisticsService;
    private final BookQueryService bookQueryService;
    private final BookManagementService bookManagementService;
    private final BookInventoryService bookInventoryService;
    private final BookStatisticsService bookStatisticsService;

    /**
     * 获取图书详情（包含统计信息）
     * 为其他服务提供兼容的图书信息，包含统计数据
     * 
     * @param bookId 图书ID
     * @return 包含统计信息的图书详情
     */
    public BookVO getBookWithStatistics(String bookId) {
        log.info("获取包含统计信息的图书详情，图书ID：{}", bookId);
        
        try {
            // 获取基本图书信息
            BookVO book = (BookVO) bookQueryService.getBookDetail(bookId);
            if (book == null) {
                return null;
            }
            
            // 这里可以添加统计信息的组装逻辑
            // 由于BookVO可能需要包含统计信息，可以通过扩展VO或者添加字段来实现
            
            return book;
        } catch (Exception e) {
            log.error("获取包含统计信息的图书详情失败，图书ID：{}", bookId, e);
            return null;
        }
    }

    /**
     * 获取作者详情（包含统计信息）
     * 为其他服务提供兼容的作者信息，包含统计数据
     * 
     * @param authorId 作者ID
     * @return 包含统计信息的作者详情
     */
    public AuthorVO getAuthorWithStatistics(String authorId) {
        log.info("获取包含统计信息的作者详情，作者ID：{}", authorId);
        
        try {
            // 获取基本作者信息
            AuthorVO author = authorQueryService.getAuthorDetail(authorId);
            if (author == null) {
                return null;
            }
            
            // 这里可以添加统计信息的组装逻辑
            // 由于AuthorVO可能需要包含统计信息，可以通过扩展VO或者添加字段来实现
            
            return author;
        } catch (Exception e) {
            log.error("获取包含统计信息的作者详情失败，作者ID：{}", authorId, e);
            return null;
        }
    }

    /**
     * 检查图书库存
     * 为其他服务提供库存检查接口
     * 
     * @param bookId 图书ID
     * @return 是否有库存
     */
    public boolean hasBookStock(String bookId) {
        log.info("检查图书库存，图书ID：{}", bookId);
        
        try {
            return bookInventoryService.isStockSufficient(bookId, 1);
        } catch (Exception e) {
            log.error("检查图书库存失败，图书ID：{}", bookId, e);
            return false;
        }
    }

    /**
     * 获取图书可借阅数量
     * 为其他服务提供库存数量查询接口
     * 
     * @param bookId 图书ID
     * @return 可借阅数量
     */
    public Integer getBookAvailableCount(String bookId) {
        log.info("获取图书可借阅数量，图书ID：{}", bookId);
        
        try {
            return bookInventoryService.getAvailableCopies(bookId);
        } catch (Exception e) {
            log.error("获取图书可借阅数量失败，图书ID：{}", bookId, e);
            return 0;
        }
    }

    /**
     * 批量获取图书信息
     * 为其他服务提供批量查询接口
     * 
     * @param bookIds 图书ID列表
     * @return 图书信息列表
     */
    public List<BookVO> getBatchBooks(List<String> bookIds) {
        log.info("批量获取图书信息，图书ID数量：{}", bookIds.size());
        
        try {
            // 这里需要实现批量查询逻辑
            // 可以通过循环调用单个查询，或者在服务层添加批量查询方法
            return bookIds.stream()
                    .map(bookQueryService::getBookDetail)
                    .map(detail -> (BookVO) detail)
                    .filter(book -> book != null)
                    .toList();
        } catch (Exception e) {
            log.error("批量获取图书信息失败", e);
            return List.of();
        }
    }

    /**
     * 批量获取作者信息
     * 为其他服务提供批量查询接口
     * 
     * @param authorIds 作者ID列表
     * @return 作者信息列表
     */
    public List<AuthorVO> getBatchAuthors(List<String> authorIds) {
        log.info("批量获取作者信息，作者ID数量：{}", authorIds.size());
        
        try {
            // 这里需要实现批量查询逻辑
            return authorIds.stream()
                    .map(authorQueryService::getAuthorDetail)
                    .filter(author -> author != null)
                    .toList();
        } catch (Exception e) {
            log.error("批量获取作者信息失败", e);
            return List.of();
        }
    }

    /**
     * 搜索图书（简化版）
     * 为其他服务提供简化的搜索接口
     * 
     * @param keyword 关键词
     * @param limit 限制数量
     * @return 图书列表
     */
    public List<BookVO> searchBooksSimple(String keyword, Integer limit) {
        log.info("简化搜索图书，关键词：{}，限制数量：{}", keyword, limit);
        
        try {
            BookQuery query = new BookQuery();
            query.setSize(limit);
            PageResult<BookVO> result = bookQueryService.searchBooks(keyword, query);
            return result.getRecords();
        } catch (Exception e) {
            log.error("简化搜索图书失败", e);
            return List.of();
        }
    }

    /**
     * 搜索作者（简化版）
     * 为其他服务提供简化的搜索接口
     * 
     * @param keyword 关键词
     * @param limit 限制数量
     * @return 作者列表
     */
    public List<AuthorVO> searchAuthorsSimple(String keyword, Integer limit) {
        log.info("简化搜索作者，关键词：{}，限制数量：{}", keyword, limit);
        
        try {
            return authorQueryService.searchAuthors(keyword, limit);
        } catch (Exception e) {
            log.error("简化搜索作者失败", e);
            return List.of();
        }
    }

    /**
     * 更新图书借阅统计
     * 为其他服务提供统计更新接口
     * 
     * @param bookId 图书ID
     * @return 更新结果
     */
    public Result<Void> updateBookBorrowStatistics(String bookId) {
        log.info("更新图书借阅统计，图书ID：{}", bookId);
        
        try {
            // 更新图书统计
            Result<Void> bookResult = bookStatisticsService.incrementBorrowCount(bookId);
            
            // 可以在这里添加更多的统计更新逻辑，比如更新作者统计、出版社统计等
            
            return bookResult;
        } catch (Exception e) {
            log.error("更新图书借阅统计失败，图书ID：{}", bookId, e);
            return Result.fail("更新统计失败");
        }
    }

    /**
     * 检查服务健康状态
     * 为其他服务提供健康检查接口
     * 
     * @return 健康状态
     */
    public boolean isHealthy() {
        try {
            // 简单的健康检查：尝试查询一个不存在的图书
            bookQueryService.getBookDetail("health-check");
            return true;
        } catch (Exception e) {
            log.warn("图书馆服务健康检查失败", e);
            return false;
        }
    }
}
